home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / WAIS / ir / ztype1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  7.5 KB  |  319 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4.   
  5.    3.26.90    Harry Morris, morris@think.com
  6.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  7. */
  8.  
  9. #define _C_Type_1_Query_
  10.  
  11. #include "ztype1.h"
  12. #include "cutil.h"
  13. #include "panic.h"
  14. #include <string.h>
  15.  
  16. #ifndef ANSI_LIKE
  17. #include "ustubs.h"
  18. #endif
  19.  
  20. /*----------------------------------------------------------------------*/
  21.  
  22. query_term*
  23. makeAttributeTerm(use,
  24.           relation,
  25.           position,
  26.           structure,
  27.           truncation,
  28.           completeness,
  29.           term)
  30. char* use;
  31. char* relation;
  32. char* position;
  33. char* structure;
  34. char* truncation;
  35. char* completeness;
  36. any* term;
  37. {
  38.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  39.  
  40.   qt->TermType = TT_Attribute;
  41.  
  42.   /* copy in the attributes */
  43.   strncpy(qt->Use,use,ATTRIBUTE_SIZE);
  44.   strncpy(qt->Relation,relation,ATTRIBUTE_SIZE);
  45.   strncpy(qt->Position,position,ATTRIBUTE_SIZE);
  46.   strncpy(qt->Structure,structure,ATTRIBUTE_SIZE);
  47.   strncpy(qt->Truncation,truncation,ATTRIBUTE_SIZE);
  48.   strncpy(qt->Completeness,completeness,ATTRIBUTE_SIZE);
  49.  
  50.   qt->Term = duplicateAny(term);
  51.  
  52.   qt->ResultSetID = NULL;
  53.  
  54.   return(qt);
  55. }
  56.  
  57. /*----------------------------------------------------------------------*/
  58.  
  59. query_term*
  60. makeResultSetTerm(resultSet)
  61. any* resultSet;
  62. { 
  63.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  64.  
  65.   qt->TermType = TT_ResultSetID;
  66.  
  67.   qt->ResultSetID = duplicateAny(resultSet);
  68.  
  69.   qt->Term = NULL;
  70.   
  71.   return(qt);
  72. }
  73.  
  74. /*----------------------------------------------------------------------*/
  75.  
  76. query_term* 
  77. makeOperatorTerm(operatorCode)
  78. char* operatorCode;
  79. {
  80.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  81.  
  82.   qt->TermType = TT_Operator;
  83.  
  84.   strncpy(qt->Operator,operatorCode,OPERATOR_SIZE);
  85.  
  86.   qt->Term = NULL;
  87.   qt->ResultSetID = NULL;
  88.  
  89.   return(qt);
  90. }
  91.  
  92. /*----------------------------------------------------------------------*/
  93.  
  94. void 
  95. freeTerm(qt)
  96. query_term* qt;
  97. {
  98.   switch (qt->TermType)
  99.     { case TT_Attribute:
  100.     freeAny(qt->Term);
  101.     break;
  102.       case TT_ResultSetID:
  103.     freeAny(qt->ResultSetID);
  104.     break;
  105.       case TT_Operator:
  106.     /* do nothing */
  107.     break;
  108.       default:
  109.     panic("Implementation error: Unknown term type %ld",
  110.           qt->TermType);
  111.     break;
  112.       }
  113.   s_free(qt);
  114. }
  115.  
  116. /*----------------------------------------------------------------------*/
  117.  
  118. #define ATTRIBUTE_LIST_SIZE    ATTRIBUTE_SIZE * 6
  119. #define AT_DELIMITER    " "
  120.  
  121. char* 
  122. writeQueryTerm(qt,buffer,len)
  123. query_term* qt;
  124. char* buffer;
  125. long* len;
  126. {
  127.   char* buf = buffer;
  128.   char attributes[ATTRIBUTE_LIST_SIZE];
  129.  
  130.   switch (qt->TermType)
  131.     { case TT_Attribute:
  132.     strncpy(attributes,qt->Use,ATTRIBUTE_LIST_SIZE); 
  133.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  134.     s_strncat(attributes,qt->Relation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  135.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  136.     s_strncat(attributes,qt->Position,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  137.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  138.     s_strncat(attributes,qt->Structure,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  139.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  140.     s_strncat(attributes,qt->Truncation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  141.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  142.     s_strncat(attributes,qt->Completeness,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE);
  143.     buf = writeString(attributes,DT_AttributeList,buf,len);
  144.     buf = writeAny(qt->Term,DT_Term,buf,len);
  145.     break;
  146.       case TT_ResultSetID:
  147.     buf = writeAny(qt->ResultSetID,DT_ResultSetID,buf,len);
  148.     break;
  149.       case TT_Operator:
  150.     buf = writeString(qt->Operator,DT_Operator,buf,len);
  151.     break;
  152.       default:
  153.     panic("Implementation error: Unknown term type %ld",
  154.           qt->TermType);
  155.     break;
  156.       }
  157.  
  158.   return(buf);
  159. }
  160.  
  161. /*----------------------------------------------------------------------*/
  162.  
  163. char* 
  164. readQueryTerm(qt,buffer)
  165. query_term** qt;
  166. char* buffer;
  167. {
  168.   char* buf = buffer;
  169.   char  *attributeList = NULL;
  170.   char* operator = NULL;
  171.   any*     term;
  172.   char* use = NULL;
  173.   char* relation = NULL;
  174.   char* position = NULL;
  175.   char* structure = NULL;
  176.   char* truncation = NULL;
  177.   char* completeness;
  178.   any*    resultSetID = NULL;
  179.   data_tag tag;
  180.  
  181.   
  182.   tag = peekTag(buffer);
  183.  
  184.   switch(tag)
  185.     { case DT_AttributeList:
  186.     buf = readString(&attributeList,buf);
  187.     buf = readAny(&term,buf);
  188.     use = strtok(attributeList,AT_DELIMITER);
  189.     relation = strtok(NULL,AT_DELIMITER);
  190.     position = strtok(NULL,AT_DELIMITER);
  191.     structure = strtok(NULL,AT_DELIMITER);
  192.     truncation = strtok(NULL,AT_DELIMITER);
  193.     completeness = strtok(NULL,AT_DELIMITER);
  194.     *qt = makeAttributeTerm(use,relation,position,structure,
  195.                 truncation,completeness,term);
  196.     s_free(attributeList);
  197.     freeAny(term);
  198.     break;
  199.       case DT_ResultSetID:
  200.     buf = readAny(&resultSetID,buf);
  201.     *qt = makeResultSetTerm(resultSetID);    
  202.     freeAny(resultSetID);
  203.     break;
  204.       case DT_Operator:
  205.     buf = readString(&operator,buf);
  206.     *qt = makeOperatorTerm(operator);
  207.     s_free(operator);
  208.     break;
  209.       default:
  210.     REPORT_READ_ERROR(buf);
  211.     break;
  212.       }
  213.   
  214.   return(buf);
  215. }
  216.  
  217. /*----------------------------------------------------------------------*/
  218.  
  219. static unsigned long getQueryTermSize _AP((query_term* qt));
  220.  
  221. static unsigned long
  222. getQueryTermSize(qt)
  223. query_term* qt;
  224. /* figure out how many bytes it will take to write this query */
  225. {
  226.   unsigned long size;
  227.   static char attributes[] = "11 22 33 44 55 66"; /* we just need this to 
  228.                              calculate its written
  229.                              size */
  230.  
  231.   switch (qt->TermType)
  232.     { case TT_Attribute:
  233.     size = writtenStringSize(DT_AttributeList,attributes);
  234.     size += writtenAnySize(DT_Term,qt->Term);
  235.     break;
  236.       case TT_ResultSetID:
  237.     size = writtenAnySize(DT_ResultSetID,qt->ResultSetID);
  238.     break;
  239.       case TT_Operator:
  240.     size = writtenStringSize(DT_Operator,qt->Operator);
  241.     break;
  242.       default:
  243.     panic("Implementation error: Unknown term type %ld",
  244.           qt->TermType);
  245.     break;
  246.       }
  247.  
  248.   return(size);
  249. }
  250.  
  251. /*----------------------------------------------------------------------*/
  252.  
  253. /* A query is simply a null terminated list of query terms. For 
  254.    transmission, a query is written into an any which is sent as
  255.    the user information field. */
  256.  
  257. any*
  258. writeQuery(terms)
  259. query_term** terms;
  260. {
  261.   any* info = NULL;
  262.   char* writePos = NULL;
  263.   char* data = NULL;
  264.   unsigned long size = 0;
  265.   long remaining = 0;
  266.   long i;
  267.   query_term* qt = NULL;
  268.  
  269.   if (terms == NULL)
  270.     return(NULL);
  271.  
  272.   /* calculate the size of write buffer */
  273.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  274.     size += getQueryTermSize(qt);
  275.  
  276.   data = (char*)s_malloc((size_t)size);
  277.  
  278.   /* write the terms */
  279.   writePos = data;
  280.   remaining = size;
  281.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  282.     writePos = writeQueryTerm(qt,writePos,&remaining);
  283.  
  284.   info = makeAny(size,data);
  285.  
  286.   return(info);
  287. }
  288.  
  289. /*----------------------------------------------------------------------*/
  290.  
  291. query_term**
  292. readQuery(info)
  293. any *info;
  294. {
  295.   char* readPos = info->bytes;
  296.   query_term** terms = NULL;
  297.   query_term* qt = NULL;
  298.   long numTerms = 0;
  299.  
  300.  
  301.   while (readPos < info->bytes + info->size)
  302.     { readPos = readQueryTerm(&qt,readPos);
  303.       if (terms == NULL)
  304.     { terms = (query_term**)s_malloc((size_t)(sizeof(query_term*)*2));
  305.     }
  306.       else
  307.     { terms = 
  308.         (query_term**)s_realloc((char*)terms,
  309.                     (size_t)(sizeof(query_term*)*(numTerms+2)));
  310.       }
  311.       terms[numTerms++] = qt;
  312.       terms[numTerms] = NULL;
  313.     }
  314.  
  315.   return(terms);
  316. }
  317.  
  318. /*----------------------------------------------------------------------*/
  319.